package com.pan.alg.niuke.stackque;

import java.util.ArrayList;
import java.util.PriorityQueue;

/**
 * 描述
 * 如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
 *
 * <p>数据范围：数据流中数个数满足 1 \le n \le 1000 \1≤n≤1000 ，大小满足 1 \le val \le 1000 \1≤val≤1000
 *
 * <p>进阶： 空间复杂度 O(n) \O(n) ， 时间复杂度 O(nlogn) \O(nlogn)
 *
 * <p>输入： [5,2,3,4,1,6,7,0,8] 复制 返回值： "5.00 3.50 3.00 3.50 3.00 3.50 4.00 3.50 4.00 " 复制 说明：
 * 数据流里面不断吐出的是5,2,3...,则得到的平均数分别为5,(5+2)/2,3...
 */
public class GetMedian {

    PriorityQueue<Integer> sq = new PriorityQueue<>((o1, o2)->o1.compareTo(o2));
    PriorityQueue<Integer> cp = new PriorityQueue<>((o1, o2)->o1.compareTo(o2));

    public void Insert(Integer num) {
        sq.add(num);
        cp.clear();
        cp.addAll(sq);
    }

    public Double GetMedian() {

        int size = cp.size();
        int indexM1 = size/2+1;
        Double middle;
        boolean isOdd ;
        if(size%2==0){
            isOdd = false;
            middle = calculateMiddle(indexM1,isOdd);

        }else{
            isOdd = true;
            middle = calculateMiddle(indexM1,isOdd);
        }


        return middle;
    }

    private Double calculateMiddle(int indexM1, boolean isOdd) {

        double result = 0.0;

        if(isOdd){
            for (int i = 0; i < indexM1 ;i++) {
                //
                result = cp.poll();
            }

        }else{
            double num1 = 0.0;
            double num2 = 0.0;
            for (int i = 0; i < indexM1 ;i++) {
                //
                Integer poll = cp.poll();
                if(i==indexM1-2){
                    num1= poll;
                }else if(i==indexM1-1){
                    num2 = poll;
                }

            }
            result = (num1+num2)/2;

        }

        return result;
    }

    public static void main(String[] args) {
    //
        GetMedian getMedian = new GetMedian();

        for (int i = 0; i < 9; i++){
            //
            getMedian.Insert(i);
        }

        Double aDouble = getMedian.GetMedian();

        System.out.println(aDouble);
    }




}

class Solution1 {

    private ArrayList<Integer> val = new ArrayList<Integer>();

    public void Insert(Integer num) {
        if(val.isEmpty()){
            //val中没有数据，直接加入
            val.add(num);
        }

            //val中有数据，需要插入排序
        else{
            int i = 0;
            //遍历找到插入点
            for(; i < val.size(); i++){
                if(num <= val.get(i)){
                    break;
                }
            }
            //插入相应位置
            val.add(i, num);
        }
    }

    public Double GetMedian() {
        int n = val.size();
        //奇数个数字
        if(n % 2 == 1){
            //类型转换
            return (double)val.get(n / 2);
        }
            //偶数个数字
        else{
            double a = val.get(n / 2);
            double b = val.get(n / 2 - 1);
            return (a + b) / 2;
        }
    }
}

class Solution2 {

    //小顶堆，元素数值都比大顶堆大
    private PriorityQueue<Integer> max = new PriorityQueue<>();
    //大顶堆，元素数值较小
    private PriorityQueue<Integer> min = new PriorityQueue<>((o1, o2)->o2.compareTo(o1));

    //维护两个堆，取两个堆顶部即与中位数相关
    public void Insert(Integer num) {
        //先加入较小部分
        min.offer(num);
        //将较小部分的最大值取出，送入到较大部分
        max.offer(min.poll());
        //平衡两个堆的数量
        if(min.size() < max.size()){
            min.offer(max.poll());
        }

    }

    public Double GetMedian() {
        //奇数个
        if(min.size() > max.size()){
            return (double)min.peek();
        }
        else{
            //偶数个
            return (double)(min.peek() + max.peek()) / 2;
        }
    }
}